home *** CD-ROM | disk | FTP | other *** search
/ Shareware Super Platinum 8 / Shareware Super Platinum 8.iso / mac / WIN_PRO / DS-1.ZIP;1 / PREPROC.ZIP / PREPROC.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-10  |  28.9 KB  |  994 lines
  1. /*
  2.  * The functions in this file handle preprocessing directives, macro
  3.  *  calls, and string concatenation.
  4.  */
  5. #include "../preproc/preproc.h"
  6. #include "../preproc/pproto.h"
  7. #include <ctype.h>
  8.  
  9. /*
  10.  * Prototypes for static functions.
  11.  */
  12. hidden novalue start_select Params((struct token *t));
  13. hidden novalue end_select   Params((struct token *t));
  14. hidden novalue incl_file    Params((struct token *t));
  15. hidden novalue define       Params((struct token *t));
  16. hidden int     expand       Params((struct token *t, struct macro *m));
  17. hidden novalue toks_to_str  Params((struct str_buf *sbuf, struct token *t));
  18.  
  19. /*
  20.  * start_select - handle #if, #ifdef, #ifndef
  21.  */
  22. static novalue start_select(t)
  23. struct token *t;
  24.    {
  25.    struct token *t1;
  26.    struct tok_lst *tlst;
  27.    int condition;
  28.    int nesting;
  29.  
  30.    /*
  31.     * determine if condition is true.
  32.     */
  33.    if (t->tok_id == PpIf)
  34.       condition = eval(t);  /* #if - evaluate expression */
  35.    else {
  36.       /*
  37.        * #ifdef or #ifndef - see if an identifier is defined.
  38.        */
  39.       t1 = NULL;
  40.       nxt_non_wh(&t1);
  41.       if (t1->tok_id != Identifier)
  42.          errt2(t1, "identifier must follow #", t->image);
  43.       condition = (m_lookup(t1) == NULL) ? 0 : 1;
  44.       if (t->tok_id == PpIfndef)
  45.          condition = !condition;
  46.       free_t(t1);
  47.       t1 = next_tok();
  48.       if (t1->tok_id != PpDirEnd)
  49.          errt2(t1, "expecting end of line following argument to #", t->image);
  50.       free_t(t1);
  51.       }
  52.  
  53.    /*
  54.     * look for the branch of the conditional inclusion to take or #endif.
  55.     */
  56.    nesting = 0;
  57.    while (!condition) {
  58.       t1 = next_tok();
  59.       if (t1 == NULL)
  60.         errt2(t, "no matching #endif for #", t->image);
  61.       switch (t1->tok_id) {
  62.          case PpIf:
  63.          case PpIfdef:
  64.          case PpIfndef:
  65.             /*
  66.              * Nested #if, #ifdef, or #ifndef in a branch of a conditional
  67.              *  that is being discarded. Contunue discarding until the
  68.              *  nesting level returns to 0.
  69.              */
  70.             ++nesting;
  71.             break;
  72.  
  73.          case PpEndif:
  74.             /*
  75.              * #endif found. See if this is this the end of a nested
  76.              *  conditional or the end of the conditional we are processing.
  77.              */
  78.             if (nesting > 0)
  79.               --nesting;
  80.             else {
  81.                /*
  82.                 * Discard any extraneous tokens on the end of the directive.
  83.                 */
  84.                while (t->tok_id != PpDirEnd) {
  85.                   free_t(t);
  86.                   t = next_tok();
  87.                   }
  88.                free_t(t);
  89.                free_t(t1);
  90.                return;
  91.                }
  92.             break;
  93.   
  94.          case PpElif:
  95.             /*
  96.              * #elif found. If this is not a nested conditional, see if
  97.              *   it has a true condition.
  98.              */
  99.             if (nesting == 0) {
  100.                free_t(t);
  101.                t = t1;
  102.                t1 = NULL;
  103.                condition = eval(t);
  104.                }
  105.             break;
  106.  
  107.          case PpElse:
  108.             /*
  109.              * #else found. If this is not a nested conditional, take
  110.              *  this branch.
  111.              */
  112.             if (nesting == 0) {
  113.                free_t(t);
  114.                t = t1;
  115.                t1 = next_tok();
  116.                /*
  117.                 * Discard any extraneous tokens on the end of the directive.
  118.                 */
  119.                while (t1->tok_id != PpDirEnd) {
  120.                   free_t(t1);
  121.                   t1 = next_tok();
  122.                   }
  123.                condition = 1;
  124.                }
  125.          }
  126.       free_t(t1);
  127.       }
  128.    tlst = new_t_lst(t);
  129.    tlst->next = src_stack->cond;
  130.    src_stack->cond = tlst;
  131.    }
  132.  
  133. /*
  134.  * end_select - handle #elif, #else, and #endif
  135.  */
  136. static novalue end_select(t)
  137. struct token *t;
  138.    {
  139.    struct tok_lst *tlst;
  140.    struct token *t1;
  141.    int nesting;
  142.  
  143.    /*
  144.     * Make sure we are processing conditional compilation and pop it
  145.     *  from the list of conditional nesting.
  146.     */
  147.    tlst = src_stack->cond;
  148.    if (tlst == NULL)
  149.       errt2(t, "invalid context for #", t->image);
  150.    src_stack->cond = tlst->next;
  151.    tlst->next = NULL;
  152.    free_t_lst(tlst);
  153.  
  154.    /*
  155.     * We are done with the selected branch for the conditional compilation.
  156.     *  Skip to the matching #endif (if we are not already there). Don't
  157.     *  be confused by nested conditionals.
  158.     */
  159.    nesting = 0;
  160.    t1 = copy_t(t);
  161.    while (t1->tok_id != PpEndif || nesting > 0) {
  162.       switch (t1->tok_id) {
  163.          case PpIf:
  164.          case PpIfdef:
  165.          case PpIfndef:
  166.             ++nesting;
  167.             break;
  168.  
  169.          case PpEndif:
  170.             --nesting;
  171.          }
  172.       free_t(t1);
  173.       t1 = next_tok();
  174.       if (t1 == NULL)
  175.         errt2(t, "no matching #endif for #", t->image);
  176.       }
  177.    free_t(t);
  178.  
  179.    /*
  180.     * Discard any extraneous tokens on the end of the #endif directive.
  181.     */
  182.    while (t1->tok_id != PpDirEnd) {
  183.       free_t(t1);
  184.       t1 = next_tok();
  185.       }
  186.    free_t(t1);
  187.    return;
  188.    }
  189.  
  190. /*
  191.  * incl_file - handle #include
  192.  */
  193. static novalue incl_file(t)
  194. struct token *t;
  195.    {
  196.    struct token *file_tok, *t1;
  197.    struct str_buf *sbuf;
  198.    char *s;
  199.    char *fname;
  200.    int line;
  201.  
  202.    file_tok = NULL;
  203.    advance_tok(&file_tok);
  204.  
  205.    /*
  206.     * Determine what form the head file name takes.
  207.     */
  208.    if (file_tok->tok_id != StrLit && file_tok->tok_id != PpHeader) {
  209.       /*
  210.        * see if macro expansion created a name of the form <...>
  211.        */
  212.       t1 = file_tok;
  213.       s = t1->image;
  214.       fname = t1->fname;
  215.       line = t1->line;
  216.       if (*s != '<')
  217.          errt1(t1, "invalid include file syntax");
  218.       ++s;
  219.  
  220.       /*
  221.        * Gather into a string buffer the characters from subsequent tokens
  222.        *  until the closing '>' is found, then create a "header" token
  223.        *  from it.
  224.        */
  225.       sbuf = get_sbuf();
  226.       while (*s != '>') {
  227.          while (*s != '\0' && *s != '>')
  228.             AppChar(*sbuf, *s++);
  229.          if (*s == '\0') {
  230.             switch (t1->tok_id) {
  231.                case StrLit:
  232.                case LStrLit:
  233.                   AppChar(*sbuf, '"');
  234.                   break;
  235.                case CharConst:
  236.                case LCharConst:
  237.                   AppChar(*sbuf, '\'');
  238.                   break;
  239.                }
  240.             free_t(t1);
  241.             t1 = interp_dir();
  242.             switch (t1->tok_id) {
  243.                case StrLit:
  244.                   AppChar(*sbuf, '"');
  245.                   break;
  246.                case LStrLit:
  247.                   AppChar(*sbuf, 'L');
  248.                   AppChar(*sbuf, '"');
  249.                   break;
  250.                case CharConst:
  251.                   AppChar(*sbuf, '\'');
  252.                   break;
  253.                case LCharConst:
  254.                   AppChar(*sbuf, 'L');
  255.                   AppChar(*sbuf, '\'');
  256.                   break;
  257.                case PpDirEnd:
  258.                   errt1(t1, "invalid include file syntax");
  259.                }
  260.             if (t1->tok_id == WhiteSpace)
  261.                AppChar(*sbuf, ' ')
  262.             else
  263.                s = t1->image;
  264.             }
  265.          }
  266.       if (*++s != '\0')
  267.          errt1(t1, "invalid include file syntax");
  268.       free_t(t1);
  269.       file_tok = new_token(PpHeader, str_install(sbuf), fname, line);
  270.       rel_sbuf(sbuf);
  271.       }
  272.  
  273.    t1 = interp_dir();
  274.    if (t1->tok_id != PpDirEnd)
  275.       errt1(t1, "invalid include file syntax");
  276.    free_t(t1);
  277.  
  278.    /*
  279.     * Add the file to the top of the token source stack.
  280.     */
  281.    if (file_tok->tok_id == StrLit)
  282.       include(t, file_tok->image, 0);
  283.    else
  284.       include(t, file_tok->image, 1);
  285.    free_t(file_tok);
  286.    free_t(t);
  287.    }
  288.  
  289. /*
  290.  * define - handle #define and #begdef
  291.  */
  292. static novalue define(t)
  293. struct token *t;
  294.    {
  295.    struct token *mname;   /* name of macro */
  296.    int category;      /* NoArgs for object-like macro, else number params */
  297.    int multi_line;
  298.    struct id_lst *prmlst; /* parameter list */
  299.    struct tok_lst *body;  /* replacement list */
  300.    struct token *t1;
  301.    struct id_lst **pilst;
  302.    struct tok_lst **ptlst;
  303.    int nesting;
  304.  
  305.    /*
  306.     * Get the macro name.
  307.     */
  308.    mname = NULL;
  309.    nxt_non_wh(&mname);
  310.    if (mname->tok_id != Identifier)
  311.       errt2(mname, "syntax error in #", t->image);
  312.    
  313.    /*
  314.     * Determine if this macro takes arguments.
  315.     */
  316.    prmlst = NULL;
  317.    t1 = next_tok();
  318.    if (t1->tok_id == '(') {
  319.       /*
  320.        * function like macro - gather parameter list
  321.        */
  322.       pilst = &prmlst;
  323.       nxt_non_wh(&t1);
  324.       if (t1->tok_id == Identifier) {
  325.          category = 1;
  326.          (*pilst) = new_id_lst(t1->image);
  327.          pilst = &(*pilst)->next;
  328.          nxt_non_wh(&t1);
  329.          while (t1->tok_id == ',') {
  330.             nxt_non_wh(&t1);
  331.             if (t1->tok_id != Identifier)
  332.                errt1(t1, "a parameter to a macro must be an identifer");
  333.             ++category;
  334.             (*pilst) = new_id_lst(t1->image);
  335.             pilst = &(*pilst)->next;
  336.             nxt_non_wh(&t1);
  337.             }
  338.          }
  339.       else
  340.          category = 0;
  341.       if (t1->tok_id != ')')
  342.          errt2(t1, "syntax error in #", t->image);
  343.       free_t(t1);
  344.       t1 = next_tok();
  345.       }
  346.    else
  347.       category = NoArgs; /* object-like macro */
  348.  
  349.    /*
  350.     * Gather the body of the macro.
  351.     */
  352.    body = NULL;
  353.    ptlst = &body;
  354.    if (t->tok_id == PpDefine) {  /* #define */
  355.       multi_line = 0;
  356.       /*
  357.        * strip leading white space
  358.        */
  359.       while (t1->tok_id == WhiteSpace) {
  360.          free_t(t1);
  361.          t1 = next_tok();
  362.          }
  363.  
  364.       while (t1->tok_id != PpDirEnd) {
  365.          /*
  366.           * Expansion of this type of macro does not trigger #line directives.
  367.           */
  368.          t1->flag &= ~LineChk;
  369.  
  370.          (*ptlst) = new_t_lst(t1);
  371.          ptlst = &(*ptlst)->next;
  372.          t1 = next_tok();
  373.          }
  374.       }
  375.    else {
  376.       /*
  377.        *  #begdef
  378.        */
  379.       multi_line = 1;
  380.       if (t1->tok_id != PpDirEnd)
  381.          errt1(t1, "expecting new-line at end of #begdef");
  382.       free_t(t1);
  383.  
  384.       /*
  385.        * Gather tokens until #enddef. Nested #begdef-#enddefs are put
  386.        *  in this macro and not processed until the macro is expanded.
  387.        */
  388.       nesting = 0;
  389.       t1 = next_tok();
  390.       while (t1 != NULL && (nesting > 0 || t1->tok_id != PpEnddef)) {
  391.          if (t1->tok_id == PpBegdef)
  392.             ++nesting;
  393.          else if (t1->tok_id == PpEnddef)
  394.             --nesting;
  395.          (*ptlst) = new_t_lst(t1);
  396.          ptlst = &(*ptlst)->next;
  397.          t1 = next_tok();
  398.          }
  399.       if (t1 == NULL)
  400.          errt1(t, "unexpected end-of-file in #begdef");
  401.       free_t(t1);
  402.       t1 = next_tok();
  403.       if (t1->tok_id != PpDirEnd)
  404.          errt1(t1, "expecting new-line at end of #enddef");
  405.       }
  406.    free_t(t1);
  407.    free_t(t);
  408.  
  409.    /*
  410.     * Install the macro in the macro symbol table.
  411.     */
  412.    m_install(mname, category, multi_line, prmlst, body);
  413.    free_t(mname);
  414.    }
  415.  
  416. /*
  417.  * expand - add expansion of macro to source stack.
  418.  */
  419. static int expand(t, m)
  420. struct token *t;
  421. struct macro *m;
  422.    {
  423.    struct token *t1 = NULL;
  424.    struct token *t2;
  425.    struct token *whsp = NULL;
  426.    union src_ref ref;
  427.    struct tok_lst **args, **exp_args;
  428.    struct tok_lst **tlp, **trail_whsp;
  429.    struct src *stack_sav;
  430.    int nparm;
  431.    int narg;
  432.    int paren_nest;
  433.    int line;
  434.    char *fname;
  435.  
  436.    ++m->ref_cnt;
  437.  
  438.    args = NULL;
  439.    exp_args = NULL;
  440.    if (m->category >= 0) {
  441.       /*
  442.        * This macro requires an argument list. Gather it, if there is one.
  443.        */
  444.       nparm = m->category;
  445.       narg = 0;
  446.       merge_whsp(&whsp, &t1, next_tok);
  447.       if (t1 == NULL || t1->tok_id != '(') {
  448.          /*
  449.           * There is no argument list. Do not expand the macro, just push
  450.           *  back the tokens we read ahead.
  451.           */
  452.          if (t1 != NULL)
  453.             src_stack->toks[src_stack->ntoks++] = t1;
  454.          if (whsp != NULL)
  455.             src_stack->toks[src_stack->ntoks++] = whsp;
  456.          --m->ref_cnt;
  457.          return 0;
  458.          }
  459.       free_t(whsp);
  460.  
  461.       /*
  462.        * See how many arguments we expect.
  463.        */
  464.       if (nparm == 0)
  465.          nxt_non_wh(&t1);
  466.       else {
  467.          /*
  468.           * Allocate an array for both raw and macro-expanded token lists
  469.           *  for the arguments.
  470.           */
  471.          args = (struct tok_lst **)alloc((unsigned int)(sizeof(struct tok_lst *)
  472.              * nparm));
  473.          exp_args = (struct tok_lst **)alloc((unsigned int)(
  474.              sizeof(struct tok_lst *) * nparm));
  475.  
  476.          /*
  477.           * Gather the tokens for each argument.
  478.           */
  479.          paren_nest = 0;
  480.          for ( ; narg < nparm && t1 != NULL && t1->tok_id != ')'; ++narg) {
  481.             /*
  482.              * Strip leading white space from the argument.
  483.              */
  484.             nxt_non_wh(&t1);
  485.             tlp = &args[narg];  /* location of raw token list for this arg */
  486.             *tlp = NULL;
  487.             trail_whsp = NULL;
  488.             /*
  489.              * Gather tokens for this argument.
  490.              */
  491.             while (t1 != NULL && (paren_nest > 0 || (t1->tok_id != ',' &&
  492.                  t1->tok_id != ')'))) {
  493.                if (t1->tok_id == '(')
  494.                   ++paren_nest;
  495.                if (t1->tok_id == ')')
  496.                   --paren_nest;
  497.                t1->flag &= ~LineChk;
  498.  
  499.                /*
  500.                 * Link this token into the list for the arguemnt. If this
  501.                 *  might be trailing white space, remember where the pointer
  502.                 *  to it is so it can be discarded later.
  503.                 */
  504.                *tlp = new_t_lst(t1);
  505.                if (t1->tok_id == WhiteSpace) {
  506.                   if (trail_whsp == NULL)
  507.                      trail_whsp = tlp;
  508.                   }
  509.                else
  510.                   trail_whsp = NULL;
  511.                tlp = &(*tlp)->next;
  512.                t1 = next_tok();
  513.                }
  514.             /*
  515.              * strip trailing white space
  516.              */
  517.             if (trail_whsp != NULL) {
  518.                free_t_lst(*trail_whsp);
  519.                *trail_whsp = NULL;
  520.                }
  521.  
  522.             /*
  523.              * Create a macro expanded token list for the argument. This is
  524.              *  done by establishing a separate preprocessing context with
  525.              *  a new source stack. The current stack must be be saved and
  526.              *  restored.
  527.              */
  528.             tlp = &exp_args[narg]; /* location of expanded token list for arg */
  529.             *tlp = NULL;
  530.             if (src_stack->flag == CharSrc)
  531.                src_stack->u.cs->next_char = next_char; /* save state */
  532.             stack_sav = src_stack;
  533.             src_stack = &dummy;
  534.             ref.tlst = args[narg];
  535.             push_src(TokLst, &ref); /* initial stack is list of raw tokens */
  536.             /*
  537.              * Get macro expanded tokens.
  538.              */
  539.             for (t2 = interp_dir(); t2 != NULL; t2 = interp_dir()) {
  540.                *tlp = new_t_lst(t2);
  541.                tlp = &(*tlp)->next;
  542.                }
  543.             src_stack = stack_sav;
  544.             if (src_stack->flag == CharSrc) {
  545.                /*
  546.                 * Restore global state for tokenizing.
  547.                 */
  548.                first_char = src_stack->u.cs->char_buf;
  549.                next_char = src_stack->u.cs->next_char;
  550.                last_char = src_stack->u.cs->last_char;
  551.                }
  552.             }
  553.          }
  554.       if (t1 == NULL)
  555.          errt2(t, "unexpected end-of-file in call to macro ", t->image);
  556.       if (t1->tok_id != ')')
  557.          errt2(t1, "too many arguments for macro call to ", t->image);
  558.       if (narg < nparm)
  559.          errt2(t1, "too few arguments for macro call to ", t->image);
  560.       free_t(t1);
  561.       }
  562.  
  563.    ++m->recurse;
  564.    ref.me = new_me(m, args, exp_args);
  565.    push_src(MacExpand, &ref);
  566.    /*
  567.     * Don't loose generation of #line directive before regular
  568.     *  macros, if there should be one.
  569.     */
  570.    if (!m->multi_line && (t->flag & LineChk)) {
  571.       line = t->line;
  572.       fname = t->fname;
  573.       t1 = next_tok();
  574.       if (t1 != NULL) {
  575.          if (!(t1->flag & LineChk)) {
  576.             t1->flag |= LineChk;
  577.             t1->line = line;
  578.             t1->fname = fname;
  579.             }
  580.          src_stack->toks[src_stack->ntoks++] = t1;
  581.          }
  582.       }
  583.    return 1;
  584.    }
  585.  
  586. /*
  587.  * toks_to_str - put in a buffer the string image of tokens up to the end of
  588.  *    of a preprocessor directive.
  589.  */
  590. static novalue toks_to_str(sbuf, t)
  591. struct str_buf *sbuf;
  592. struct token *t;
  593.    {
  594.    char *s;
  595.  
  596.    while (t->tok_id != PpDirEnd) {
  597.       if (t->tok_id == WhiteSpace)
  598.          AppChar(*sbuf, ' ')
  599.       else {
  600.          if (t->tok_id == LCharConst || t->tok_id == LStrLit)
  601.             AppChar(*sbuf, 'L')
  602.          if (t->tok_id == CharConst || t->tok_id == LCharConst)
  603.             AppChar(*sbuf, '\'')
  604.          else if (t->tok_id == StrLit || t->tok_id == LStrLit)
  605.             AppChar(*sbuf, '"')
  606.          for (s = t->image; *s != '\0'; ++s)
  607.             AppChar(*sbuf, *s)
  608.          if (t->tok_id == CharConst || t->tok_id == LCharConst)
  609.             AppChar(*sbuf, '\'')
  610.          else if (t->tok_id == StrLit || t->tok_id == LStrLit)
  611.             AppChar(*sbuf, '"')
  612.          }
  613.       free_t(t);
  614.       t = next_tok();
  615.       }
  616.    free_t(t);
  617.    }
  618.  
  619. /*
  620.  * interp_dir - interpret preprocessing directives and recognize macro calls.
  621.  */
  622. struct token *interp_dir()
  623.    {
  624.    struct token *t, *t1;
  625.    struct macro *m;
  626.    struct str_buf *sbuf;
  627.    char *s;
  628.  
  629.    /*
  630.     * See if the caller pushed back any tokens
  631.     */
  632.    if (src_stack->ntoks > 0)
  633.       return src_stack->toks[--src_stack->ntoks];
  634.  
  635.    for (;;) {
  636.       t = next_tok();
  637.       if (t == NULL)
  638.           return NULL;
  639.  
  640.       switch (t->tok_id) {
  641.          case PpIf:          /* #if */
  642.          case PpIfdef:       /* #ifdef */
  643.          case PpIfndef:      /* #endif */
  644.             start_select(t);
  645.             break;
  646.             
  647.          case PpElif:        /* #elif */
  648.          case PpElse:        /* #else */
  649.          case PpEndif:       /* #endif */
  650.             end_select(t);
  651.             break;
  652.  
  653.          case PpInclude:     /* #include */
  654.             incl_file(t);
  655.             break;
  656.  
  657.          case PpDefine:      /* #define */
  658.          case PpBegdef:      /* #begdef */
  659.             define(t);
  660.             break;
  661.  
  662.          case PpEnddef:      /* #endif, but we have not seen an #begdef */
  663.             errt1(t, "invalid context for #enddef");
  664.  
  665.          case PpUndef:       /* #undef */
  666.             /*
  667.              * Get the identifier and delete it from the macro symbol table.
  668.              */
  669.             t1 = NULL;
  670.             nxt_non_wh(&t1);
  671.             if (t1->tok_id != Identifier)
  672.                errt1(t1, "#undef requires an identifer argument");
  673.             m_delete(t1);
  674.             free_t(t1);
  675.             t1 = next_tok();
  676.             if (t1->tok_id != PpDirEnd)
  677.                errt1(t1, "syntax error for #undef");
  678.             free_t(t1);
  679.             free_t(t);
  680.             break;
  681.  
  682.          case PpLine:        /* #line */
  683.             /* this directive is handled in next_tok() */
  684.             break;
  685.  
  686.          case PpError:       /* #error */
  687.             /*
  688.              * Create an error message out of the rest of the tokens
  689.              *  in this directive.
  690.              */
  691.             sbuf = get_sbuf();
  692.             t1 = NULL;
  693.             nxt_non_wh(&t1);
  694.             toks_to_str(sbuf, t1);
  695.             errt1(t, str_install(sbuf));
  696.             break;
  697.  
  698.          case PpPragma:       /* #pramga */
  699.          case PpSkip:
  700.             /*
  701.              * Ignore all pragmas and all non-ANSI directives that need not
  702.              *   be passed to the caller.
  703.              */
  704.             t1 = next_tok();
  705.             while (t1->tok_id != PpDirEnd) {
  706.                free_t(t1);
  707.                t1 = next_tok();
  708.                }
  709.             free_t(t);
  710.             free_t(t1);
  711.             break;
  712.  
  713.          case PpKeep:
  714.             /*
  715.              * This is a directive special to an application using
  716.              *  this preprocessor. Pass it on to the application.
  717.              */
  718.             sbuf = get_sbuf();
  719.             AppChar(*sbuf, '#')
  720.             for (s = t->image; *s != '\0'; ++s)
  721.                AppChar(*sbuf, *s)
  722.             toks_to_str(sbuf, next_tok());
  723.             t->image = str_install(sbuf);
  724.             rel_sbuf(sbuf);
  725.             return t;
  726.  
  727.          case PpNull:         /* # */
  728.             free_t(t);
  729.             free_t(next_tok());   /* must be PpDirEnd */
  730.             break;
  731.  
  732.          default:
  733.             /*
  734.              * This is not a directive, see if it is a macro name.
  735.              */
  736.             if (t->tok_id == Identifier && !(t->flag & NoExpand) &&
  737.                  (m = m_lookup(t)) != NULL) {
  738.                if (max_recurse < 0 || m->recurse < max_recurse) {
  739.                   if (expand(t, m))
  740.                      free_t(t);
  741.                   else
  742.                      return t;
  743.                   }
  744.                else {
  745.                   t->flag |= NoExpand;
  746.                   return t;
  747.                   }
  748.                }
  749.             else
  750.                return t; /* nothing special, just return it */
  751.          }
  752.       }
  753.    }
  754.  
  755.  
  756. /*
  757.  * See if compiler used to build the preprocessor recongizes '\a' 
  758.  *  as the bell character.
  759.  */
  760. #if '\a' == Bell
  761.  
  762. #define TokSrc interp_dir
  763.  
  764. #else      /*  '\a' == Bell  */
  765.  
  766. #define TokSrc check_bell
  767.  
  768. /*
  769.  * fix_bell - replace \a characters which correct octal escape sequences.
  770.  */
  771. static char *fix_bell(s)
  772. register char *s;
  773.    {
  774.    struct str_buf *sbuf;
  775.  
  776.    sbuf = get_sbuf();
  777.    while (*s != '\0') {
  778.       AppChar(*sbuf, *s);
  779.       if (*s == '\\') {
  780.          ++s;
  781.          if (*s == 'a') {
  782.             AppChar(*sbuf, '0' + ((Bell >> 6) & 7))
  783.             AppChar(*sbuf, '0' + ((Bell >> 3) & 7))
  784.             AppChar(*sbuf, '0' + (Bell & 7))
  785.             }
  786.          else
  787.             AppChar(*sbuf, *s);
  788.          }
  789.       ++s;
  790.       }
  791.    s = str_install(sbuf);
  792.    rel_sbuf(sbuf);
  793.    return s;
  794.    }
  795.  
  796. /*
  797.  * check_bell - check for \a in character and string constants. This is only
  798.  *  used with compilers which don't give the standard interpretation to \a.
  799.  */
  800. static struct token *check_bell()
  801.    {
  802.    struct token *t;
  803.    register char *s;
  804.  
  805.    t = interp_dir();
  806.    if (t == NULL)
  807.       return NULL;
  808.    switch (t->tok_id) {
  809.       case StrLit:
  810.       case LStrLit:
  811.       case CharConst:
  812.       case LCharConst:
  813.          s = t->image;
  814.          while (*s != '\0') {
  815.            if (*s == '\\') {
  816.               if (*++s == 'a') {
  817.                  /*
  818.                   * There is at least one \a to replace.
  819.                   */
  820.                  t->image = fix_bell(t->image);
  821.                  break;
  822.                  }
  823.               }
  824.            ++s;
  825.            }
  826.       }
  827.    return t;
  828.    }
  829.  
  830. #endif     /*  '\a' == Bell  */
  831.  
  832. /*
  833.  * preproc - return the next fully preprocessed token.
  834.  */
  835. struct token *preproc()
  836.    {
  837.    struct token *t1, *whsp, *t2, *str;
  838.    struct str_buf *sbuf;
  839.    int i;
  840.    char *escape_seq;
  841.    char *s;
  842.    char hex_char;
  843.    int is_hex_char;
  844.  
  845.    t1 = TokSrc();
  846.    if (t1 == NULL)
  847.       return NULL;  /* end of file */
  848.  
  849.    /*
  850.     * Concatentate ajacent strings. There is a potential problem if the
  851.     *  first string ends in a octal or hex constant and the second string
  852.     *  starts with a corresponding digit. For example the strings "\12"
  853.     *  and  "7" should be concatenated to produce the 2 character string
  854.     *  "\0127" not the one character string "\127". When such a situation
  855.     *  arises, the last character of the first string is converted to a
  856.     *  canonical 3-digit octal form.
  857.     */
  858.    if (t1->tok_id == StrLit || t1->tok_id == LStrLit) {
  859.       /*
  860.        * See what the next non-white space token is, but don't discard any
  861.        *  white space yet.
  862.        */
  863.       whsp = NULL;
  864.       merge_whsp(&whsp, &t2, TokSrc);
  865.       if (t2 != NULL && (t2->tok_id == StrLit || t2->tok_id == LStrLit)) {
  866.          /*
  867.           * There are at least two adjacent string literals, concatenate them.
  868.           */
  869.          sbuf = get_sbuf();
  870.          str = copy_t(t1);
  871.          while (t2 != NULL && (t2->tok_id == StrLit || t2->tok_id == LStrLit)) {
  872.             s = t1->image;
  873.             while (*s != '\0') {
  874.                if (*s == '\\') {
  875.                   AppChar(*sbuf, *s);
  876.                   ++s;
  877.                   if (*s == 'x') {
  878.                      /*
  879.                       * Hex escape sequence.
  880.                       */
  881.                      hex_char = 0;
  882.                      escape_seq = s;
  883.                      ++s;
  884.                      is_hex_char = 1;
  885.                      while (is_hex_char) {
  886.                         if (*s >= '0' && *s <= '9')
  887.                            hex_char = (hex_char << 4) | (*s - '0');
  888.                         else switch (*s) {
  889.                            case 'a': case 'A':
  890.                               hex_char = (hex_char << 4) | 10;
  891.                               break;
  892.                            case 'b': case 'B':
  893.                               hex_char = (hex_char << 4) | 11;
  894.                               break;
  895.                            case 'c': case 'C':
  896.                               hex_char = (hex_char << 4) | 12;
  897.                               break;
  898.                            case 'd': case 'D':
  899.                               hex_char = (hex_char << 4) | 13;
  900.                               break;
  901.                            case 'e': case 'E':
  902.                               hex_char = (hex_char << 4) | 14;
  903.                               break;
  904.                            case 'f': case 'F':
  905.                               hex_char = (hex_char << 4) | 15;
  906.                               break;
  907.                            default: is_hex_char = 0;
  908.                            }
  909.                         if (is_hex_char)
  910.                            ++s;
  911.                         }
  912.                      /*
  913.                       * If this escape secquence is at the end of the
  914.                       *  string and the next string starts with a
  915.                       *  hex digit, use the canonical form, otherwise
  916.                       *  use it as is.
  917.                       */
  918.                      if (*s == '\0' && isxdigit(t2->image[0])) {
  919.                         AppChar(*sbuf, ((hex_char >> 6) & 03) + '0');
  920.                         AppChar(*sbuf, ((hex_char >> 3) & 07) + '0');
  921.                         AppChar(*sbuf, (hex_char        & 07) + '0');
  922.                         }
  923.                      else
  924.                         while (escape_seq != s)
  925.                            AppChar(*sbuf, *escape_seq++);
  926.                      }
  927.                   else if (*s >= '0' && *s <= '7') {
  928.                      /*
  929.                       * Octal escape sequence.
  930.                       */
  931.                      escape_seq = s;
  932.                      i = 1;
  933.                      while (i <= 3 && *s >= '0' && *s <= '7') { 
  934.                         ++i;
  935.                         ++s;
  936.                         }
  937.                      /*
  938.                       * If this escape secquence is at the end of the
  939.                       *  string and the next string starts with an
  940.                       *  octal digit, extend it to 3 digits, otherwise
  941.                       *  use it as is.
  942.                       */
  943.                      if (*s == '\0' && t2->image[0] >= '0' &&
  944.                            t2->image[0] <= '7' && i <= 3) {
  945.                         AppChar(*sbuf, '0');
  946.                         if (i <= 2)
  947.                            AppChar(*sbuf, '0');
  948.                         }
  949.                      while (escape_seq != s)
  950.                         AppChar(*sbuf, *escape_seq++);
  951.                      }
  952.                   }
  953.                else {
  954.                   /*
  955.                    * Not an escape sequence, just copy the character to the
  956.                    *  buffer.
  957.                    */
  958.                   AppChar(*sbuf, *s);
  959.                   ++s;
  960.                   }
  961.                }
  962.             free_t(t1);
  963.             t1 = t2;
  964.  
  965.             /*
  966.              * Get the next non-white space token, saving any skipped
  967.              *  white space.
  968.              */
  969.             merge_whsp(&whsp, &t2, TokSrc);
  970.             }
  971.  
  972.          /*
  973.           * Copy the image of the last token into the buffer, creating
  974.           *  the image for the concatenated token.
  975.           */
  976.          for (s = t1->image; *s != '\0'; ++s)
  977.             AppChar(*sbuf, *s);
  978.          str->image = str_install(sbuf);
  979.          free_t(t1);
  980.          t1 = str;
  981.          rel_sbuf(sbuf);
  982.          }
  983.  
  984.       /*
  985.        * Push back any look-ahead tokens.
  986.        */
  987.       if (t2 != NULL)
  988.          src_stack->toks[src_stack->ntoks++] = t2;
  989.       if (whsp != NULL)
  990.          src_stack->toks[src_stack->ntoks++] = whsp;
  991.       }
  992.    return t1;
  993.    }
  994.